{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 一、文本分类回归\n",
    "\n",
    "\n",
    "## 1、基本操作\n",
    "\n",
    "安装网址：https://www.lfd.uci.edu/~gohlke/pythonlibs/#xgboost\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# <img src=\"./img/2.png\" alt=\"FAO\" width=\"690\">\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "[[2.]]\n"
     ]
    }
   ],
   "source": [
    "# 创建一个变量\n",
    "w = tf.Variable([[0.5,1.0]])\n",
    "x = tf.Variable([[2.0],[1.0]]) \n",
    "\n",
    "y = tf.matmul(w, x)  \n",
    "\n",
    "\n",
    "#全局变量初始化\n",
    "init_op = tf.global_variables_initializer()\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init_op)\n",
    "    print (y.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tensorflow很多操作跟numpy有些类似的\n",
    "\n",
    "* tf.zeros([3, 4], int32) ==> [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n",
    "\n",
    "* tf.zeros_like(tensor) ==> [[0, 0, 0], [0, 0, 0]]\n",
    "\n",
    "* tf.ones([2, 3], int32) ==> [[1, 1, 1], [1, 1, 1]]\n",
    "\n",
    "* tf.ones_like(tensor) ==> [[1, 1, 1], [1, 1, 1]]\n",
    "\n",
    "* tensor = tf.constant([1, 2, 3, 4, 5, 6, 7]) => [1 2 3 4 5 6 7]\n",
    "\n",
    "* tensor = tf.constant(-1.0, shape=[2, 3]) => [[-1. -1. -1.]                                              [-1. -1. -1.]]\n",
    "* tf.linspace(10.0, 12.0, 3, name=\"linspace\") => [ 10.0  11.0  12.0]\n",
    "\n",
    "* tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4.623951   -0.71513474 -0.45783484]\n",
      " [ 4.83856    -2.784391    4.8454795 ]]\n",
      "[[5 6]\n",
      " [1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "#生成的值服从具有指定平均值和标准偏差的正态分布\n",
    "norm = tf.random_normal([2, 3], mean=-1, stddev=4)\n",
    "\n",
    "# 洗牌\n",
    "c = tf.constant([[1, 2], [3, 4], [5, 6]])\n",
    "shuff = tf.random_shuffle(c)\n",
    "\n",
    "# 每一次执行结果都会不同\n",
    "sess = tf.Session()\n",
    "print (sess.run(norm))\n",
    "print (sess.run(shuff))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# 累加器\n",
    "state = tf.Variable(0)\n",
    "new_value = tf.add(state, tf.constant(1))\n",
    "update = tf.assign(state, new_value)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(state))    \n",
    "    for _ in range(3):\n",
    "        sess.run(update)\n",
    "        print(sess.run(state))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# 结构转换\n",
    "import numpy as np\n",
    "a = np.zeros((3,3))\n",
    "ta = tf.convert_to_tensor(a)\n",
    "with tf.Session() as sess:\n",
    "     print(sess.run(ta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-6-333eff69d5a8>:8: div (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Deprecated in favor of operator or tf.math.divide.\n",
      "a = 5.0\n",
      "b = 10.0\n",
      "a + b = 15.0\n",
      "a - b = -5.0\n",
      "a*b = 50.0\n",
      "a/b = 0.5\n"
     ]
    }
   ],
   "source": [
    "# 基本算法\n",
    "a = tf.constant(5.0)\n",
    "b = tf.constant(10.0)\n",
    "\n",
    "x = tf.add(a, b, name=\"add\")\n",
    "y = tf.subtract(a, b, name=None)\n",
    "z = tf.multiply(a, b, name=\"multiplication\")\n",
    "w = tf.div(a, b, name=\"divide\")\n",
    "\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(\"a =\", sess.run(a))\n",
    "    print(\"b =\", sess.run(b))\n",
    "    print(\"a + b =\", sess.run(x))\n",
    "    print(\"a - b =\", sess.run(y))\n",
    "    print(\"a*b =\", sess.run(z))\n",
    "    print(\"a/b =\", sess.run(w))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([14.], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "# 占位操作\n",
    "input1 = tf.placeholder(tf.float32)\n",
    "input2 = tf.placeholder(tf.float32)\n",
    "output = tf.multiply(input1, input2)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、线性回归\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import numpy as np\n",
    "# import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 随机生成1000个点，围绕在y=0.1x+0.3的直线周围\n",
    "num_points = 1000\n",
    "vectors_set = []\n",
    "for i in range(num_points):\n",
    "    x1 = np.random.normal(0.0, 0.55)\n",
    "    y1 = x1 * 0.1 + 0.3 + np.random.normal(0.0, 0.03)\n",
    "    vectors_set.append([x1, y1])\n",
    "\n",
    "# 生成一些样本\n",
    "x_data = [v[0] for v in vectors_set]\n",
    "y_data = [v[1] for v in vectors_set]\n",
    "\n",
    "plt.scatter(x_data,y_data,c='g')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 生成1维的W矩阵，取值是[-1,1]之间的随机数\n",
    "W = tf.Variable(tf.random_uniform([1], -1.0, 1.0), name='W')\n",
    "# 生成1维的b矩阵，初始值是0\n",
    "b = tf.Variable(tf.zeros([1]), name='b')\n",
    "# 经过计算得出预估值y\n",
    "y = W * x_data + b\n",
    "\n",
    "# 以预估值y和实际值y_data之间的均方误差作为损失\n",
    "loss = tf.reduce_mean(tf.square(y - y_data), name='loss')\n",
    "# 采用梯度下降法来优化参数\n",
    "optimizer = tf.train.GradientDescentOptimizer(0.5)\n",
    "# 训练的过程就是最小化这个误差值\n",
    "train = optimizer.minimize(loss, name='train')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W = [-0.9269972] b = [0.] loss = 0.38417068\n",
      "W = [-0.640977] b = [0.29756233] loss = 0.15454786\n",
      "W = [-0.43416518] b = [0.29796442] loss = 0.08091246\n",
      "W = [-0.28492817] b = [0.29825515] loss = 0.042569216\n",
      "W = [-0.1772376] b = [0.29846492] loss = 0.022603206\n",
      "W = [-0.09952727] b = [0.29861632] loss = 0.01220656\n",
      "W = [-0.0434509] b = [0.29872555] loss = 0.006792841\n",
      "W = [-0.00298575] b = [0.29880437] loss = 0.003973822\n",
      "W = [0.02621421] b = [0.29886127] loss = 0.002505909\n",
      "W = [0.04728512] b = [0.2989023] loss = 0.0017415405\n",
      "W = [0.06249006] b = [0.29893193] loss = 0.0013435206\n",
      "W = [0.07346205] b = [0.2989533] loss = 0.0011362645\n",
      "W = [0.08137953] b = [0.29896873] loss = 0.0010283428\n",
      "W = [0.08709285] b = [0.29897985] loss = 0.00097214594\n",
      "W = [0.09121562] b = [0.2989879] loss = 0.00094288314\n",
      "W = [0.09419064] b = [0.29899368] loss = 0.00092764554\n",
      "W = [0.09633744] b = [0.29899785] loss = 0.00091971114\n",
      "W = [0.09788658] b = [0.2990009] loss = 0.0009155795\n",
      "W = [0.09900446] b = [0.29900306] loss = 0.0009134281\n",
      "W = [0.09981113] b = [0.29900464] loss = 0.00091230776\n",
      "W = [0.10039323] b = [0.29900578] loss = 0.00091172446\n"
     ]
    }
   ],
   "source": [
    "# 执行\n",
    "sess = tf.Session()\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "\n",
    "# 初始化的W和b是多少\n",
    "print (\"W =\", sess.run(W), \"b =\",sess.run(b) , \"loss =\", sess.run(loss))\n",
    "# 执行20次训练\n",
    "for step in range(20):\n",
    "    sess.run(train)\n",
    "    # 输出训练好的W和b\n",
    "    print (\"W =\", sess.run(W), \"b =\", sess.run(b), \"loss =\", sess.run(loss))\n",
    "#writer = tf.train.SummaryWriter(\"./tmp\", sess.graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x_data,y_data,c='g')\n",
    "plt.plot(x_data,sess.run(W)*x_data+sess.run(b))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、逻辑回归\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-13-bbde23ab0faa>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./data/V/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./data/V/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./data/V/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./data/V/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/apple/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      " 类型是 <class 'tensorflow.contrib.learn.python.learn.datasets.base.Datasets'>\n",
      " 训练数据有 55000\n",
      " 测试数据有 10000\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets('./data/V/', one_hot=True)\n",
    "\n",
    "print (\" 类型是 %s\" % (type(mnist)))\n",
    "print (\" 训练数据有 %d\" % (mnist.train.num_examples))\n",
    "print (\" 测试数据有 %d\" % (mnist.test.num_examples))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 数据类型 is <class 'numpy.ndarray'>\n",
      " 标签类型 <class 'numpy.ndarray'>\n",
      " 训练集的shape (55000, 784)\n",
      " 训练集的标签的shape (55000, 10)\n",
      " 测试集的shape' is (10000, 784)\n",
      " 测试集的标签的shape (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "trainimg   = mnist.train.images\n",
    "trainlabel = mnist.train.labels\n",
    "testimg    = mnist.test.images\n",
    "testlabel  = mnist.test.labels\n",
    "\n",
    "print (\" 数据类型 is %s\"    % (type(trainimg)))\n",
    "print (\" 标签类型 %s\"  % (type(trainlabel)))\n",
    "print (\" 训练集的shape %s\"   % (trainimg.shape,))\n",
    "print (\" 训练集的标签的shape %s\" % (trainlabel.shape,))\n",
    "print (\" 测试集的shape' is %s\"    % (testimg.shape,))\n",
    "print (\" 测试集的标签的shape %s\"  % (testlabel.shape,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17921th 训练数据 标签是 7\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29920th 训练数据 标签是 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14879th 训练数据 标签是 8\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25309th 训练数据 标签是 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29925th 训练数据 标签是 7\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 查看\n",
    "nsample = 5\n",
    "randidx = np.random.randint(trainimg.shape[0], size=nsample)\n",
    "\n",
    "for i in randidx:\n",
    "    curr_img   = np.reshape(trainimg[i, :], (28, 28)) # 28 by 28 matrix \n",
    "    curr_label = np.argmax(trainlabel[i, :] ) # Label\n",
    "    plt.matshow(curr_img, cmap=plt.get_cmap('gray'))\n",
    "    print (\"\" + str(i) + \"th 训练数据 \" \n",
    "           + \"标签是 \" + str(curr_label))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置的参数\n",
    "numClasses = 10\n",
    "inputSize = 784  \n",
    "trainingIterations = 50000\n",
    "batchSize = 128\n",
    "\n",
    "X = tf.placeholder(tf.float32, shape = [None, inputSize])\n",
    "y = tf.placeholder(tf.float32, shape = [None, numClasses])\n",
    "\n",
    "# 参数初始化\n",
    "W1 = tf.Variable(tf.random_normal([inputSize, numClasses], stddev=0.1))\n",
    "B1 = tf.Variable(tf.constant(0.1), [numClasses])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构造模型\n",
    "y_pred = tf.nn.softmax(tf.matmul(X, W1) + B1)\n",
    "\n",
    "loss = tf.reduce_mean(tf.square(y - y_pred))\n",
    "opt = tf.train.GradientDescentOptimizer(learning_rate = .05).minimize(loss)\n",
    "\n",
    "correct_prediction = tf.equal(tf.argmax(y_pred,1), tf.argmax(y,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0, training accuracy 0.257812\n",
      "step 1000, training accuracy 0.5625\n",
      "step 2000, training accuracy 0.789062\n",
      "step 3000, training accuracy 0.867188\n",
      "step 4000, training accuracy 0.867188\n",
      "step 5000, training accuracy 0.8125\n",
      "step 6000, training accuracy 0.84375\n",
      "step 7000, training accuracy 0.84375\n",
      "step 8000, training accuracy 0.796875\n",
      "step 9000, training accuracy 0.882812\n",
      "step 10000, training accuracy 0.789062\n",
      "step 11000, training accuracy 0.875\n",
      "step 12000, training accuracy 0.84375\n",
      "step 13000, training accuracy 0.867188\n",
      "step 14000, training accuracy 0.929688\n",
      "step 15000, training accuracy 0.960938\n",
      "step 16000, training accuracy 0.90625\n",
      "step 17000, training accuracy 0.851562\n",
      "step 18000, training accuracy 0.90625\n",
      "step 19000, training accuracy 0.921875\n",
      "step 20000, training accuracy 0.890625\n",
      "step 21000, training accuracy 0.914062\n",
      "step 22000, training accuracy 0.875\n",
      "step 23000, training accuracy 0.914062\n",
      "step 24000, training accuracy 0.90625\n",
      "step 25000, training accuracy 0.914062\n",
      "step 26000, training accuracy 0.929688\n",
      "step 27000, training accuracy 0.90625\n",
      "step 28000, training accuracy 0.914062\n",
      "step 29000, training accuracy 0.90625\n",
      "step 30000, training accuracy 0.890625\n",
      "step 31000, training accuracy 0.929688\n",
      "step 32000, training accuracy 0.921875\n",
      "step 33000, training accuracy 0.898438\n",
      "step 34000, training accuracy 0.929688\n",
      "step 35000, training accuracy 0.882812\n",
      "step 36000, training accuracy 0.875\n",
      "step 37000, training accuracy 0.90625\n",
      "step 38000, training accuracy 0.914062\n",
      "step 39000, training accuracy 0.9375\n",
      "step 40000, training accuracy 0.929688\n",
      "step 41000, training accuracy 0.96875\n",
      "step 42000, training accuracy 0.921875\n",
      "step 43000, training accuracy 0.90625\n",
      "step 44000, training accuracy 0.875\n",
      "step 45000, training accuracy 0.90625\n",
      "step 46000, training accuracy 0.867188\n",
      "step 47000, training accuracy 0.828125\n",
      "step 48000, training accuracy 0.914062\n",
      "step 49000, training accuracy 0.90625\n"
     ]
    }
   ],
   "source": [
    "# 运行\n",
    "sess = tf.Session()\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "\n",
    "for i in range(trainingIterations):\n",
    "    batch = mnist.train.next_batch(batchSize)\n",
    "    batchInput = batch[0]\n",
    "    batchLabels = batch[1]\n",
    "    _, trainingLoss = sess.run([opt, loss], feed_dict={X: batchInput, y: batchLabels})\n",
    "    if i%1000 == 0:\n",
    "        train_accuracy = accuracy.eval(session=sess, feed_dict={X: batchInput, y: batchLabels})\n",
    "        print (\"step %d, training accuracy %g\"%(i, train_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test accuracy 0.914062\n"
     ]
    }
   ],
   "source": [
    "# 测试\n",
    "batch = mnist.test.next_batch(batchSize)\n",
    "testAccuracy = sess.run(accuracy, feed_dict={X: batch[0], y: batch[1]})\n",
    "print (\"test accuracy %g\"%(testAccuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、全连接神经网络NN\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/V/train-images-idx3-ubyte.gz\n",
      "Extracting ./data/V/train-labels-idx1-ubyte.gz\n",
      "Extracting ./data/V/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./data/V/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./data/V/\", one_hot=True)\n",
    "\n",
    "# 参数设置\n",
    "numClasses = 10 \n",
    "inputSize = 784 \n",
    "numHiddenUnits = 50 \n",
    "trainingIterations = 10000 \n",
    "batchSize = 64\n",
    "\n",
    "X = tf.placeholder(tf.float32, shape = [None, inputSize])\n",
    "y = tf.placeholder(tf.float32, shape = [None, numClasses])\n",
    "\n",
    "W1 = tf.Variable(tf.truncated_normal([inputSize, numHiddenUnits], stddev=0.1))\n",
    "B1 = tf.Variable(tf.constant(0.1), [numHiddenUnits])\n",
    "W2 = tf.Variable(tf.truncated_normal([numHiddenUnits, numClasses], stddev=0.1))\n",
    "B2 = tf.Variable(tf.constant(0.1), [numClasses])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 单层神经网络\n",
    "hiddenLayerOutput = tf.matmul(X, W1) + B1\n",
    "hiddenLayerOutput = tf.nn.relu(hiddenLayerOutput)\n",
    "finalOutput = tf.matmul(hiddenLayerOutput, W2) + B2\n",
    "finalOutput = tf.nn.relu(finalOutput)\n",
    "\n",
    "# 损失与学习率\n",
    "loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels = y, logits = finalOutput))\n",
    "opt = tf.train.GradientDescentOptimizer(learning_rate = 0.3).minimize(loss)\n",
    "\n",
    "# 正确率\n",
    "correct_prediction = tf.equal(tf.argmax(finalOutput,1), tf.argmax(y,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0, training accuracy 0.171875\n",
      "step 1000, training accuracy 1\n",
      "step 2000, training accuracy 1\n",
      "step 3000, training accuracy 1\n",
      "step 4000, training accuracy 1\n",
      "step 5000, training accuracy 1\n",
      "step 6000, training accuracy 0.984375\n",
      "step 7000, training accuracy 1\n",
      "step 8000, training accuracy 1\n",
      "step 9000, training accuracy 1\n"
     ]
    }
   ],
   "source": [
    "# 运行\n",
    "sess = tf.Session()\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "\n",
    "for i in range(trainingIterations):\n",
    "    batch = mnist.train.next_batch(batchSize)\n",
    "    batchInput = batch[0]\n",
    "    batchLabels = batch[1]\n",
    "    _, trainingLoss = sess.run([opt, loss], feed_dict={X: batchInput, y: batchLabels})\n",
    "    if i%1000 == 0:\n",
    "        trainAccuracy = accuracy.eval(session=sess, feed_dict={X: batchInput, y: batchLabels})\n",
    "        print (\"step %d, training accuracy %g\"%(i, trainAccuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 两层神经网络 - 参数设置\n",
    "numHiddenUnitsLayer2 = 100\n",
    "trainingIterations = 10000\n",
    "\n",
    "X = tf.placeholder(tf.float32, shape = [None, inputSize])\n",
    "y = tf.placeholder(tf.float32, shape = [None, numClasses])\n",
    "\n",
    "W1 = tf.Variable(tf.random_normal([inputSize, numHiddenUnits], stddev=0.1))\n",
    "B1 = tf.Variable(tf.constant(0.1), [numHiddenUnits])\n",
    "W2 = tf.Variable(tf.random_normal([numHiddenUnits, numHiddenUnitsLayer2], stddev=0.1))\n",
    "B2 = tf.Variable(tf.constant(0.1), [numHiddenUnitsLayer2])\n",
    "W3 = tf.Variable(tf.random_normal([numHiddenUnitsLayer2, numClasses], stddev=0.1))\n",
    "B3 = tf.Variable(tf.constant(0.1), [numClasses])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 两层神经网络 - 网络结构\n",
    "hiddenLayerOutput = tf.matmul(X, W1) + B1\n",
    "hiddenLayerOutput = tf.nn.relu(hiddenLayerOutput)\n",
    "hiddenLayer2Output = tf.matmul(hiddenLayerOutput, W2) + B2\n",
    "hiddenLayer2Output = tf.nn.relu(hiddenLayer2Output)\n",
    "finalOutput = tf.matmul(hiddenLayer2Output, W3) + B3\n",
    "\n",
    "# 损失与学习率\n",
    "loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels = y, logits = finalOutput))\n",
    "opt = tf.train.GradientDescentOptimizer(learning_rate = 0.3).minimize(loss)\n",
    "\n",
    "# 正确率\n",
    "correct_prediction = tf.equal(tf.argmax(finalOutput,1), tf.argmax(y,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0, training accuracy 0.375\n",
      "step 1000, training accuracy 0.984375\n",
      "step 2000, training accuracy 1\n",
      "step 3000, training accuracy 1\n",
      "step 4000, training accuracy 1\n",
      "step 5000, training accuracy 1\n",
      "step 6000, training accuracy 1\n",
      "step 7000, training accuracy 1\n",
      "step 8000, training accuracy 1\n",
      "step 9000, training accuracy 1\n",
      "testing accuracy: 0.9764000177383423\n"
     ]
    }
   ],
   "source": [
    "# 两层神经网络 - 运行\n",
    "sess = tf.Session()\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "\n",
    "for i in range(trainingIterations):\n",
    "    batch = mnist.train.next_batch(batchSize)\n",
    "    batchInput = batch[0]\n",
    "    batchLabels = batch[1]\n",
    "    _, trainingLoss = sess.run([opt, loss], feed_dict={X: batchInput, y: batchLabels})\n",
    "    if i%1000 == 0:\n",
    "        train_accuracy = accuracy.eval(session=sess, feed_dict={X: batchInput, y: batchLabels})\n",
    "        print (\"step %d, training accuracy %g\"%(i, train_accuracy))\n",
    "\n",
    "# 测试\n",
    "testInputs = mnist.test.images\n",
    "testLabels = mnist.test.labels\n",
    "acc = accuracy.eval(session=sess, feed_dict = {X: testInputs, y: testLabels})\n",
    "print(\"testing accuracy: {}\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、卷积神经网络CNN\n",
    "    \n",
    "### 5.1、MNIST手写数字\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import random\n",
    "import datetime\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/V/train-images-idx3-ubyte.gz\n",
      "Extracting ./data/V/train-labels-idx1-ubyte.gz\n",
      "Extracting ./data/V/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./data/V/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./data/V/\", one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 图像输入大小\n",
    "tf.reset_default_graph() \n",
    "sess = tf.InteractiveSession()\n",
    "x = tf.placeholder(\"float\", shape = [None, 28,28,1]) #shape in CNNs is always None x height x width x color channels\n",
    "y_ = tf.placeholder(\"float\", shape = [None, 10]) #shape is always None x number of classes\n",
    "\n",
    "# 卷积核和偏置参数\n",
    "W_conv1 = tf.Variable(tf.truncated_normal([5, 5, 1, 32], stddev=0.1))#shape is filter x filter x input channels x output channels\n",
    "b_conv1 = tf.Variable(tf.constant(0.1, shape = [32])) #shape of the bias just has to match output channels of the filter\n",
    "\n",
    "# 卷积与池化设置 - 第一层\n",
    "h_conv1 = tf.nn.conv2d(input=x, filter=W_conv1, strides=[1, 1, 1, 1], padding='SAME') + b_conv1\n",
    "h_conv1 = tf.nn.relu(h_conv1)\n",
    "h_pool1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "\n",
    "# 封装卷积与池化\n",
    "def conv2d(x, W):\n",
    "    return tf.nn.conv2d(input=x, filter=W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "def max_pool_2x2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-30-9e8d0e7307c1>:16: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    }
   ],
   "source": [
    "# 网络结构\n",
    "# Second Conv and Pool Layers\n",
    "W_conv2 = tf.Variable(tf.truncated_normal([5, 5, 32, 64], stddev=0.1))\n",
    "b_conv2 = tf.Variable(tf.constant(.1, shape = [64]))\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "h_pool2 = max_pool_2x2(h_conv2)\n",
    "\n",
    "# First Fully Connected Layer\n",
    "W_fc1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1024], stddev=0.1))\n",
    "b_fc1 = tf.Variable(tf.constant(.1, shape = [1024]))\n",
    "h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "\n",
    "# Dropout Layer\n",
    "keep_prob = tf.placeholder(\"float\")\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "# Second Fully Connected Layer\n",
    "W_fc2 = tf.Variable(tf.truncated_normal([1024, 10], stddev=0.1))\n",
    "b_fc2 = tf.Variable(tf.constant(.1, shape = [10]))\n",
    "\n",
    "# Final Layer\n",
    "y = tf.matmul(h_fc1_drop, W_fc2) + b_fc2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 损失与评价指标\n",
    "crossEntropyLoss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels = y_, logits = y))\n",
    "trainStep = tf.train.AdamOptimizer().minimize(crossEntropyLoss)\n",
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0, training accuracy 0.06\n",
      "step 10, training accuracy 0.5\n",
      "step 20, training accuracy 0.7\n",
      "step 30, training accuracy 0.9\n",
      "step 40, training accuracy 0.8\n",
      "step 50, training accuracy 0.94\n",
      "step 60, training accuracy 0.9\n",
      "step 70, training accuracy 0.94\n",
      "step 80, training accuracy 0.94\n",
      "step 90, training accuracy 0.96\n"
     ]
    }
   ],
   "source": [
    "# 运行\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "batchSize = 50\n",
    "for i in range(100):\n",
    "    batch = mnist.train.next_batch(batchSize)\n",
    "    trainingInputs = batch[0].reshape([batchSize,28,28,1])\n",
    "    trainingLabels = batch[1]\n",
    "    if i%10 == 0:\n",
    "        trainAccuracy = accuracy.eval(session=sess, feed_dict={x:trainingInputs, y_: trainingLabels, keep_prob: 1.0})\n",
    "        print (\"step %d, training accuracy %g\"%(i, trainAccuracy))\n",
    "    trainStep.run(session=sess, feed_dict={x: trainingInputs, y_: trainingLabels, keep_prob: 0.3})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2、CIFAR-10图像分类\n",
    "\n",
    "    主要是查看中间过程的结果图\n",
    "\n",
    "网址：http://www.cs.toronto.edu/~kriz/cifar.html\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle\n",
    "import random\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 解压文件\n",
    "def unpickle(file):\n",
    "    fo = open(file, 'rb')\n",
    "    dict = pickle.load(fo, encoding='latin1')\n",
    "    fo.close()\n",
    "    return dict\n",
    "\n",
    "\n",
    "# 读取图片\n",
    "def read_data(directory):\n",
    "    names = unpickle('{}/batches.meta'.format(directory))['label_names']\n",
    "    print('names', names)\n",
    "\n",
    "    data, labels = [], []\n",
    "    for i in range(1, 6):\n",
    "        filename = '{}/data_batch_{}'.format(directory, i)\n",
    "        batch_data = unpickle(filename)\n",
    "        if len(data) > 0:\n",
    "            data = np.vstack((data, batch_data['data']))\n",
    "            labels = np.hstack((labels, batch_data['labels']))\n",
    "        else:\n",
    "            data = batch_data['data']\n",
    "            labels = batch_data['labels']\n",
    "\n",
    "    print(np.shape(data), np.shape(labels))\n",
    "\n",
    "    data = clean(data)\n",
    "    data = data.astype(np.float32)\n",
    "    return names, data, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 图像预处理\n",
    "def clean(data):\n",
    "    imgs = data.reshape(data.shape[0], 3, 32, 32)\n",
    "    grayscale_imgs = imgs.mean(1)\n",
    "    cropped_imgs = grayscale_imgs[:, 4:28, 4:28]\n",
    "    img_data = cropped_imgs.reshape(data.shape[0], -1)\n",
    "    img_size = np.shape(img_data)[1]\n",
    "    means = np.mean(img_data, axis=1)\n",
    "    meansT = means.reshape(len(means), 1)\n",
    "    stds = np.std(img_data, axis=1)\n",
    "    stdsT = stds.reshape(len(stds), 1)\n",
    "    adj_stds = np.maximum(stdsT, 1.0 / np.sqrt(img_size))\n",
    "    normalized = (img_data - meansT) / adj_stds\n",
    "    return normalized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "names ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
      "(50000, 3072) (50000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 图像显示\n",
    "names, data, labels = read_data('./data/V/cifar-10-batches-py')\n",
    "\n",
    "random.seed(1)\n",
    "\n",
    "\n",
    "def show_some_examples(names, data, labels):\n",
    "    plt.figure()\n",
    "    rows, cols = 4, 4\n",
    "    random_idxs = random.sample(range(len(data)), rows * cols)\n",
    "    for i in range(rows * cols):\n",
    "        plt.subplot(rows, cols, i + 1)\n",
    "        j = random_idxs[i]\n",
    "        plt.title(names[labels[j]])\n",
    "        img = np.reshape(data[j, :], (24, 24))\n",
    "        plt.imshow(img, cmap='Greys_r')\n",
    "        plt.axis('off')\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('cifar_examples.png')\n",
    "\n",
    "show_some_examples(names, data, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    一张图片举例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "names ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
      "(50000, 3072) (50000,)\n"
     ]
    }
   ],
   "source": [
    "# 查看中间过程--开始\n",
    "names, data, labels = read_data('./data/V/cifar-10-batches-py')\n",
    "\n",
    "    \n",
    "def show_conv_results(data, filename=None):\n",
    "    plt.figure()\n",
    "    rows, cols = 4, 8\n",
    "    for i in range(np.shape(data)[3]):\n",
    "        img = data[0, :, :, i]\n",
    "        plt.subplot(rows, cols, i + 1)\n",
    "        plt.imshow(img, cmap='Greys_r', interpolation='none')\n",
    "        plt.axis('off')\n",
    "    if filename:\n",
    "        plt.savefig(filename)\n",
    "    else:\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "def show_weights(W, filename=None):\n",
    "    plt.figure()\n",
    "    rows, cols = 4, 8\n",
    "    for i in range(np.shape(W)[3]):\n",
    "        img = W[:, :, 0, i]\n",
    "        plt.subplot(rows, cols, i + 1)\n",
    "        plt.imshow(img, cmap='Greys_r', interpolation='none')\n",
    "        plt.axis('off')\n",
    "    if filename:\n",
    "        plt.savefig(filename)\n",
    "    else:\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "raw_data = data[4, :]\n",
    "raw_img = np.reshape(raw_data, (24, 24))\n",
    "plt.figure()\n",
    "plt.imshow(raw_img, cmap='Greys_r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 网络参数\n",
    "x = tf.reshape(raw_data, shape=[-1, 24, 24, 1])\n",
    "W = tf.Variable(tf.random_normal([5, 5, 1, 32]))\n",
    "b = tf.Variable(tf.random_normal([32]))\n",
    "\n",
    "conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "conv_with_b = tf.nn.bias_add(conv, b)\n",
    "conv_out = tf.nn.relu(conv_with_b)\n",
    "\n",
    "k = 2\n",
    "maxpool = tf.nn.max_pool(conv_out, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weights:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convolution results:\n",
      "(1, 24, 24, 32)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convolution with bias and relu:\n",
      "(1, 24, 24, 32)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maxpool after all the convolutions:\n",
      "(1, 12, 12, 32)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAADuCAYAAAAgAly4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztnXncTWXbhp8nRFQyRuY5iTIUTSKapGjWbGj8SpPSiEpSiXpLKYpeZSjRpBQhJJkSiWgwJENREsn8/dXZ8fqte1mPYb/f6juPv87ftp+9rn2ve932da7rvlb2jh07sowxxqSP/f7bARhjjNk9vIAbY0xK8QJujDEpxQu4McakFC/gxhiTUryAG2NMSvECbowxKcULuDHGpJTcmThIdna2dgsddNBBen379u18j/T69ev3egz33nuvdLdu3bJD7zvmmGMUKzc5MdaCBQtKM+7Vq1dLH3LIIdIHHnig9NatW6W//fZb6cWLF0vzuDt27AjGynEtVapUZHx58uSRXrBggXTu3H+f+ly5ckn/9ttvocNFcvTRR0vPmjUrGGuDBg0U6y+//BIZa4kSJSL/dsmSJdJFixaVLlSokDTHfuLEibuMOzSuHNP/Fscee6z01KlTE53//wvEzdUaNWpEXldly5aVzps3r/TSpUulOVf5nj///FN60aJF0pxfuxNrgQIFFOCmTZv0er58+aQPPvhgaV7f3333nfR++/39+/jwww+X/v3336U5t3cnVv8CN8aYlOIF3BhjUkpGLBTCdOOPP/6QZroRshyYMlWqVEn60EMPjXz/tGnTpA844IBE8RUrVkyadgKtn82bN0uXKVNGmhYA0zimYdQ81rZt26SZPsbBMdh///2lN27cKM2Us0aNGtJM4ziuIfuFttaqVaukv/jii0SxcvwYE60mfu9q1apJM/1cu3atNNPYc845R/qKK66Q5ri8+eabiWLd25xwwgnSFSpUkKb9xrmW9PwT2mCcSzl9D+0K2lWcIzwHSeF55vmnLcHrqmTJktIcG9ovnM8NGzaU5lxjrC+99FKiWEM2L+PesmWLNK8NWpnLli2Tnjt3buSxOAd2py+Vf4EbY0xK8QJujDEpJSMWSpUqVaR/+OEHaaZ0TN1og9Bm2LBhgzRTo5UrV0pXrlxZ+qSTTpJesWJFolh//fXXyNeZMjEmfh9aQvxuTJOYStLWof3C7xBHnTp1pD///HNppse0QWitFChQIPIz+d1C54eVJ0nTfX4ubQ2ON1+nTcPvkz9/fmlW7tAeoQ3UuHFj6csuuyxRrHsDWgBMpSdPnix9/PHHSx9zzDHSX331VaJjMF1n2v/1119Hvj9kARCec9oHRYoUkeb8ZNVFHJwzPLe0R0L2ImNlfPwcrg28lmgDtW3bNlGstLnKlSsnPXr0aOkGDRpIswKKsfJzeN3Tcvn++++lf/75Z2las3H4F7gxxqQUL+DGGJNSMmKhMO3l3WxaK7QfmFYxBWLKVK9ePWnaAV9++aX0jz/+KD1p0iTpZ599NhgrbQnaD0wnWTHDVJlpJq0Ffh++p3jx4tK0U0Ip8M7Url1bmvYIj1e6dOnIz2WKlsS+qlq1amQMc+bMSRQrzy9TS84Njg1tE/4tzwPjo43GNPvTTz+VrlWrVqJY9wYhy44VVqwE+te//pXjY5QvX16aVhSvK6brtCg4Rhxfbo5iVQgtHl57vBbi4DE472kbsKqI85ljxuPxcxYuXBj5Hn7P0BzeGVpwoWuAVSWcw/PmzYuMjxZP/fr1pVk9QzuW614c/gVujDEpxQu4McaklIxYKKFNA7RTaFecccYZ0qEUi6kxLZF77rlH+sUXX5QePHhwolgHDRokzbvWtGNmz54tfdxxx0W+HrJ4mNIyZeLGFd7hjoN2AjctMbXm+DG1ZprJFPCzzz6TbtKkifSJJ54oXbhwYek1a9YkipXjRyuD55HjxPcwDeZ3YFVF7969pZkCc7PHmWeemSjWv2AFAqsoWHXA2Fj98Prrr0d+JjedHXbYYdJMmcePH58oPl4/tEdYGUL7gbGyaqVu3brStBq5yYZ/e9ZZZ0mHqpl2hnFwPWDlEeczrwdeVzVr1pT+4IMPpDk/OS84j3hNxsFzNGHCBGnaqxw/2k5cM6ZOnSrNKhSuMT169Ij8W16TcfgXuDHGpBQv4MYYk1IyYqHwji3TMt6ZDfULYTrE1JXpKjexsD0lU6GkMI1jqvPTTz9JM218//33pZs3by5N64K9PAYMGCDNahF+ZtJU7/777498nbGSNm3aSDO9O/XUU6U53uxzwmobWlmsKImD37Vr166R7+GGJ1or7CXClriNGjWSPuqoo6THjBkjPWXKFOl27dolivUvOA85x2gnsHooVGnAsWaVD1+nXZWUmTNn7vI9odbMPB+MiZVAnEec56zGaNasmXTc5pNPPvlEOkn/HFYVsfqsevXq0uedd570O++8I92yZUvpjz/+WJr2WxwDBw6UPvLII6V5frmm0UKhtUIbiFYje7IwbvbzYfVLHP4FbowxKcULuDHGpJTs3WlhmOOD7MGTQ2g/sM9A6MkXtEBYzcH+EuvWrQs+4eLqq69WrEnbT+4KWgAVK1aUnjFjhjRT7ttuu026Vq1a++SJLLz7zw0bIZhK3nfffdLcHPTAAw8EY61Zs6ZiDbXWzCms4mjatKn00KFDpfnd7rjjDukePXrs9SfycK5yvPjkJVYeJangSfpEpv8WtCUWLlyY0Vhpl4Z68tByueCCC6QfeuihfR4rq+loCXGe0KYaN26cNK2YuPXKv8CNMSaleAE3xpiUkhELpXbt2jpI0ie47AreseWd3Ouvv1760ksvlWaKvWnTpmBK0r59e8XKzSF7QseOHaXZTpSbZri5gdUzK1euzGhayk1ATPHZt4MbXNjzI25cs7KyFCsrXXi3nZt99oSLLrooMj5uQHrrrbciY506dariZH+NW2+9VTrJQ3MJz//jjz8e+R5uFOKYjB49+v+0hULi7J7evXsr1vbt2+/1Y/P6ZpUM27WykmjVqlXBWEuWLKlYaX3sa6699lpp9rZ5/fXXbaEYY8w/DS/gxhiTUjKykYdVC2yxeNNNN0kzfWaKylanI0eOlD755JOlaUswlWKfEm44iIOVDYxv2LBh0txQREI9X5g2c/MBLZpOnTpJc2NAHOeff740n+7SoUOHRH//F9xcxc0HbBVLC4Xnh5uX4mDfDm5mYo8MPmGHFUd8nW1JWd1x++23S7NfBjf7JOnbwQoBVgZxE8fYsWMjX+emmVdeeUWaaTg3xLRu3VqaFTJ80s7uwE1N69atk160aFGOPoe9Ofr3779HMR177LHSTz/9tDRtOl7rjJVzj5t6XnjhBWn2GrnkkkukOYc5LnHwfHFTEC3PnForrPritfrII49Evu52ssYY8w/HC7gxxqSUjFgo7KPBDQ60NUJPMGGKyh4hw4cPl2YqxfaPbCebtPqFxzj99NOlmfYtWbJEOvRQVt7xpkXB9qZsy0lbpk+fPoliZTres2dPabbWpN3Bh+uGHi7dpUuXyM/kHXKm02+99VaiWPlZjPupp56SZgvNUB8b9phhNUvfvn2l2Z+F1SNJ+kuwv8iQIUOkuSmMqS43JTGejz76SPrqq6+WZvUUU3pu6kraC4fQpqQ1Q1uH85DzjZtgmOpz7Ah7yiS10C6//HLpWbNmSbPnDauEQhvNOJ+5CYYbdkaNGiXNVrS8npPCmC688EJpVonQHqSmJdSiRQtp9iR6/vnnpXldPPTQQ4ni8y9wY4xJKV7AjTEmpWTEQmEvkFNOOUWa7SeZPvOuM1uXsnrhzjvvlGY6wzSR1k3SB5qy/wk3OdHiYe8V9jbh+4844gjpu+66S5opIL8/W9fSromD7+Nd8dCTXhgr0332j2FlB+0BVovQEuDd/ziYiq5du1b6vffei4yb8GlNTK1pNfCpMpxLtDKSWBM8zxyXZ555RppWGZ/+wxbHtKgIK4R4/riBKimsVuF5pj1C24jjyM1YrHqixXfzzTdLs3XxvffeK037LQ6eZ16voacH0TrlOed3CM099iCh/cJWuXGwIqhz587S33zzjTStqdD85FrE78b1kJYgLbWkfZj8C9wYY1KKF3BjjEkpGbFQ+MBdPrCVKQPTE6Z0tEF4p553nWmz8A45rZikcAPBLbfcIk3LgWkz7zQzfWJMbLnKShCmWPxMbiaJg1YOU39WFTB140YWxsoNSLzT3qtXL2k+2YbfmRsl4mCqSKuEFT2cG4yP34Hn4eGHH5amnUDboF+/ftJMe1kNQlgtwUoYbiDZE2hd8JwnrTwi3OxEm45WGceCNhZtJm6u4/fnnGLlCGOtXbu2dOPGjYOxjhgxQpoVWnwaEB9SzDnG+DgvaG/wup83b15k3LS1brzxxmCsL7/8svTFF18szfWH8dHK4VylLcYNVXzg9fLly6V5XXDdi8O/wI0xJqV4ATfGmJSSkXayxhhj9j7+BW6MMSnFC7gxxqQUL+DGGJNSvIAbY0xK8QJujDEpxQu4McakFC/gxhiTUryAG2NMSvECbowxKcULuDHGpBQv4MYYk1K8gBtjTErxAm6MMSnFC7gxxqQUL+DGGJNSvIAbY0xK8QJujDEpxQu4McakFC/gxhiTUryAG2NMSsmdiYOUL18+8snJpUqVkv7jjz+k8+fPL/37779LH3TQQdLLli2TLlOmjHSJEiWkFy9eLD1z5kzpHTt2ZIdizc7OVqy5c/89PAUKFJD+7bffQn/LY0S+54ADDpCuUKGC9A8//CDN7xwXa65cuXQQfu6mTZukt27dGvpzwXFl3OvXr5euWLGidOPGjaWLFi0q/eijjyYa1/8Wl156qfSgQYMiY2Wc/M4855yfnLe//vqr9Pbt23c7Tp6PdevWBce0Vq1aO/A+vZ43b15pzotffvlFOk+ePNLVq1eX5nebMWOGNOdUrVq1pJcsWSI9b968HJ//XLlySW/bti3057tN+fLlpXn+u3Xrttfm6n77/f07eE/Oe4i4NcC/wI0xJqVkh34p7k3q1aung/BXarFixaT5Pzn/F+P/yoUKFZI++OCDpfnrmL8+DjnkEGn+qnniiSdy/L9vkl/XOYX/c5cuXVq6SZMm0v3799+jXwr8BcZfV2vWrImMI1++fNIbN26UTvKdk2Y2/NVF9uQX2P777y/NecLvf9FFF0k/9thjkbGWKlVKcS5fvlyvH3bYYdIcoy1btkgz/iJFikhzHhLOeY4vs7G4Ma1atar+6MADD4z8LF4PzMZWr14tzUyLn1O4cGFpzgVmI7xWV65cGYw1T548CipJVrgvrjeSdK7uCziXSpYsKU33gI7BihUr/AvcGGP+aXgBN8aYlJKRm5hMaZk+8aYP0/jQzUpaJUxvaQ2E0mfebIqjXLly0kw/Fy1aJM20p2DBgtJMS//8809ppoBr166VZvq5dOlS6S+++CJRrKEbQEw/eSOWY1+1atXIWH/++efIuPcUnlPepN1bbN68WXrVqlXSHKPp06fv8nOOPfZY6bfeeks6ZFFwDp9yyinSnIe0XL766ivpOnXqRMZJSyMOnlteP6Hzz/PcsGHDyO9A/d1330V+Ps/laaedlihWjh+vAZLENuHNV74niS2TFN6Yp4307bffSrMAgePK78bzzhvIP/30k3RoXaKlGod/gRtjTErxAm6MMSklIxZK3bp1pWmJMN3g3fwqVapI08ZgOsg7tpMmTYo8LtOcI488MlGsPAZTcVY50O5gasjUt169etJJLZG/CNWZ7wzTblY60KKgvUSbgSlnyOLiGNNC2h1of+0tCyVJ/S2tpfHjx+/yM1kZxc9nCsxzznT7yy+/lF64cKH0ZZddJk2Lhunzp59+Kk0bI46jjz5aeuLEidKsXy9evLg07bHRo0dLb9iwQbpGjRrSTOMXLFggTfuSYxQHq3JCFgrHlXXntGwY0+zZs6VbtGghzXM1efJk6aQ12ieffLI0rx9WB9FeIrRtQ3YPX+f85LFYax+Hf4EbY0xK8QJujDEpJSMWCi0E2gOfffaZ9FFHHSXN9I4p6vHHHy9Nu4Jp6SeffCJ9xBFHSDNNjIPVGUxxDz30UGluW+Z7TjjhBGmmffzb9957T5oWCFPdpHf2TzzxRGmmzbwrPnXqVGneUaeV9f3330d+PlsU0IKaO3duovgIrYmVK1dGvofxMQ3mHGAqys1I3DJN62zWrFnSodSdsErkkksukWblEecej0WbaNq0adLvvvuudOfOnaWPO+446aZNm0rffffdu4wzK+s/52qjRo2kx44dK82xK1u2rDTH9+KLL5aeM2dO5N+uWLFCmhYYY4iDFVq0fvj3I0aMkOZ4fPjhh9LcUES++eYb6dNPP12atgntlDh4fQ8fPlyaFWc817R1aDvyOmR1G6/JkL3WsmXLRLH6F7gxxqQUL+DGGJNSMtILpUWLFjrIO++8s9ufw7vU3ARB+4Gp4bhx46Rbt24tPWDAgEQd3lh5UblyZWnaMUwNWeXBNPHwww+XprXCdJXpFtOw4cOHB2Pt27evYm3VqpVep2X1448/SofST1oorLBhKk77qn379tK0EMqUKfNf6y9B+4V2EjtS8lyFemEwzjZt2uh1Vh3QiuCcpE3EucD5wvGldXHeeecxBum8efMGx3TWrFmK9eWXX9brrKLg+aedxCqpf//739J33XWX9EcffSTN78y5yiqUzp07Jzr/b7/9tl6nRcEeIbRpWMFCC/a1116Tpi1Hu+/yyy+X5hy55ppr9vlcZe+defPmSbOPE6uPhg4dKs31rUqVKu6FYowx/zS8gBtjTErJSBUKLY5QpUESePefGxcI02f2pmBKGwc3YzA9pC3BYn1aUEwteXf9pZdeijwW7RRaNLwbHwc3ZrC/Au/I08rhBgzaNNw0wDSWG5lYPcE7+9zglBQ+QIDWBD+LtkMSm49zKafzKsSAAQNy9H5WETRr1kyaDy5h5RE3FnXr1k36wQcflL7ggguCx+vdu7d07dq1pWmb0LLhezhGgwcPlmZl2BVXXCHdr18/aW7qYb+PpLAnDedkpUqVpFkxxGoYWig8P3ydVWxs2ctKnUzw+uuv5+j9tEFJ3Pz3L3BjjEkpXsCNMSalZKQKpXbt2joIKxhoa9A2YD+Gp556SjrU+6Jv377StC54Z5467mkc99xzj2Jt27atXudTctingdZFEhgr09UhQ4ZI8/tPnz59rz3lhJtdaDUx3a9WrZo0089XX31VmlYWN7iMHj06GGvevHkVKzc1cDMSqy9YGUPLirYRN8Kw8uD999+PjI+VDa+++mpkrBMnTlScd955p17nxpycwmcx0q4gTJ9ZtdSlS5fgmN56662Klf1suHGIFgd7DBFWRfA802ahrcP3P/TQQ3z/PqnsoO1KW6dDhw7SvA5ZYcMNMXzP5MmTg7G2atVKsbLSJZOwJ9OWLVtchWKMMf80vIAbY0xKyYiF0r59ex2Ed85ffPFFabZYZC8C9h9gCsw2syx6HzRokDQ3rrBvxtChQ4MpSeHChRUr23oyRWXrW9oJbAfJHikTJkyQZt8E2hi0D1idsm7dumCsHTt2VKysymGvhX0B42PlwKxZsxKl0D179tTrbAnKMeD4cRMJN6nQ+mF1Bz+HG2RofY0cOTIy1jFjxijOU089Va+fe+650nxST07h3GEFBjdKsYokzu5bvny5Yr3nnnv0+sCBA6VZ2UPLkuPFNYDXEqtFRo0aJc0NJ7Q14zbI5c6dWwd5+OGH9foTTzwhzWt0T7jvvvukWd1zww03SD/33HOJ5uoDDzyg12n9sSqHlWuhVsm0e1glw/n5zDPPSNO+ipsD/gVujDEpxQu4McaklIxYKCVKlNBB2BqSFsXXX38tzafLcHMMU2M+gYPv593brl27SrPFZJ06dRJVS7A9LCtGCMePFkrz5s2lmd5yEwtTMqb3HTt2lL7tttuCsTZo0EAH5xNgkj7RZVfcf//90mx7ye9A4lK9mjVrKlb22Dj//PP599I8jxwnWij8nqwYYQ8KzhnaPd26dYuMtXXr1gqC1UB8cgpbibK/CjeT0A5gZQfTbVabXHnlldKsSIpNn/fbL9JCYSqe06cfsZqJ85B2ZJ8+faQ57o8//ngw1v/5n/9RrByzYcOG5Si+JHAecb7QZowbV1oonD+MlXMpVB1Hu4xzhvOKsG8P2/c2aNDAFooxxvzT8AJujDEpJSO9ULiZgDYD+zTwSTqERfxMY1kVwM07TM/ZT4FVLnFwQwU3vnADCft08G4x035+t8ceeyzyWKyuYNUFe5DEEao2Oeecc6TZZpPxMUVj21xaTawW4HdgZVDSBzCzL83IkSOlkz4l5S/YIpjVGjy/bI965plnRh6X1QmEvWNq1qwpTYuLx6Lm3Oa4c36yvSkrsliRxCdJxcFNcexnw7FmHyI+hYnVU+zD06NHD+levXpFfs7tt98uHXq60s6wfwrPIe0x2jScq7zuaZvx+qSF2L9/f+lQz6Q4aBfecccd0qHrnv2DaLmw0odPtyJ8WhftqwYNGiSK1b/AjTEmpXgBN8aYlJIRC4V3gq+77jppbuLIaQtQpkmsVGH/jvnz50vz6SpxVRpMM1k9wLvLSWA69PHHH0tzYwCtDj6ZI2l/FT4Nh1U57GfCtJ7pGjdC8YkntA0mTZok3bBhQ+nPP/9cOmk72TfeeEP66aefTvQ3UdA2IbSjaKNx7JPANHnKlCnSbCfMzVi0BxkDU2n246B1wUoV/m337t0Txco5zXNFO4bXAK0v9ohhu1baG506dZJm5QTj5veJg5vzWHFDOJc4rrQiaK3QZmDFTLt27aRvueUWaVaVxcHNgFyX+DDvUOUbN0LVr19fmmPMDVw8P6xm4TxkBcvO+Be4McakFC/gxhiTUjKykccYY8zex7/AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpXsCNMSaleAE3xpiU4gXcGGNSihdwY4xJKV7AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpuTNxkEKFCunJyblz/33IYsWKSW/dujVSb968OfL11atXS2/fvl06yUOad+zYkR36t+zs7L3ylOf9999f+sILL5Q+9NBDpfPnzy/duHFj6cmTJ0t36tQpGGu9evUU6++//67XDznkEOn99ov+P3rVqlXSlSpVkj711FOlq1atKv3VV19Jf/3119Lly5eX7tq16z4fV45ZoUKFpGvXri19/PHHS/M7fP7559LdunWLjHVP4syTJ4805/lhhx0mnTdvXumDDjpIetu2bdIzZsyQjpurpUqVUqy8TnjO+bmckxzHP//8U3rLli3SlStXlj788MMj//bDDz+UXrhwYTDWIkWKKFaOwbp166Tz5csnnStXLmle6zyf559/vnTZsmWllyxZIr1s2TLpGjVqSHfs2DEY64EHHqhYDzjgAL3OceU4cf3hnOTrpUuXli5YsKD0WWedxeNGfofOnTsHY/UvcGOMSSlewI0xJqVkJ7Ec9pT69evrIEzdmYoRpli//PKLNNN12i+FCxeWXrNmjfR3330nzeOuWLFin6f6e4u4FLpBgwaKdcWKFXqd6doff/whffDBB0e+zhR148aN0rRl+P7diTUt47ov4mTqfcwxx0jT6uK5oaXVvXv3RGPKv6GdUqBAAemff/5ZmnbPb7/9Jk2bkjZBCFor8+fPT2Sh8JpmHDwe4+ac5Fhy/Gj9Va9ePfL906ZNk3777beDsZYsWVKx8rwwjk2bNkVq2kDZ2X8fImT/kgoVKkhfeuml0g8//LAtFGOM+afhBdwYY1JKRqpQatasKf3TTz9JM9XbsGGDdMmSJaWZktAm+OGHH6SrVasmXaJECemGDRtKL126dLdizwm8y8/vtq9gFQNhBQSrXmiJ8O46NdO4X3/9VZpW2/r166WZAu8r+H2Yiu4LOBaswpg7d640rT+m6xwjWnmc81OnTpWmTVC3bl1pWgNx8O8rVqwYeTxaX6eccoo00/uZM2dKc46EzjMtF9qdcdBmIKy8CNk35cqVk2bVCi2N119/XZoVLFx7WJESBy3ZlStXRh67TJky0qz0oT3CMaYVE7KOFy1aJN29e3fphx9+OBirf4EbY0xK8QJujDEpJSMWSijVo23Cu8Xc+MC0h5/D9J5315nOVKlSRbpUqVI5jrtIkSLSTC1pj9DG4HuOOOIIado9/A5Mz3aHWrVqSfPOPlM3pmscA44rvwNT/HPOOUeamz2YJn7//fe7FXtO2Ne2CWFa/uWXX0rTxuG85aabECGri58zceLESN23b9/g5/I80yrjHKPtOG7cOGlufDr66KOlaR/MmTNHetasWdK0CrlZJQ6OK+F1HILWAqHdVbRoUWlWnNEeSgptIVq4fD20NnBDHm00jhPn1dlnnx15LI5xHP4FbowxKcULuDHGpJSMWCi8O8+UjqkR70Yz3WBFCtN4WhTs08HUkH/LO9NxsDcBUzEeb+DAgdKh1HDevHmRr/M77CkLFy6UPvnkk6VHjx4tzb4LrB6g9cEKAfYR+eijj6SbNGkizXSVm6viYA8L9q3gsadPny7N+RDa+LAv4HejZgyMjRbAxRdfLP3JJ59Is6rk008/3WUMtBnjuO+++6Rp5bASi+f8qKOOkqb9wpiaN28uzTnPCgxetxyjOGgP0C6lFUHrh9VQtCi4Oe/HH3+U5oYiVnx88803ieIjXK+WL18eeQzGQbujePHi0lzHaAOed9550lwPedykVWz+BW6MMSnFC7gxxqSUjPRC2ZP+EkzRmW4xVZk0aZI0U7VLLrlEmm0eH3zwwWBvgdmzZytW3pEfO3asNFNAplJ8feTIkdK0N6ZMmSLN1PXqq6+WZi+TLl26BGO96qqrFCvTO1oop512mvTs2bOzot5PG4Dfgakh0+Y77rhDmpUw+fLlC8b67rvvKtZGjRrpdbamZVXGt99+K7127drI7zBmzBhp3vGvV6+eNO0LVivNmDEjMtYTTzxRcbIKg/ONG2WY3hOOHTfQcD6zvS37dJC4/jILFy5rLb08AAASzUlEQVRUrH369NHrderUkf7444+lef2wXSnPPyu3TjrpJGlePxxrzvPBgwcn6i9ywgkn6HVaCIT2Je2U0EYeVnZwDoeqZDLRt4eVS6xg4bjSWqFlSeJi9S9wY4xJKV7AjTEmpWSkCmVPWLx4caTm5gj2bODd9ddee02aaUsc7LvA9JupL3tkHHnkkdJM73g3nzHRumDRP4/FdDUOVtnQjuGdd6b43NRDi6J169bSrNbhRgm+h/0/+Dkcl53huPLcsQ0q7TxuOuJ4MBVlZQhtjS5dukhzUxirX0JwQxTHLmSVhNJ1VkMxTX7++ed3GUNSaCfxGKNGjZJmNQMrklip0qBBA2lufBkxYoQ05/C5554rnaTNcFbWf8499ifh9cNzS2uN1xUrT1i1wqfz8HMGDx4sTSsmDl5Lb7/9tnS/fv2kea5p8ZHQU8Y++OADafbAadu2rTTPTxz+BW6MMSnFC7gxxqSUjLeTZdVG0vQrCqa0rLrgJptXX31VOmkvFKZJHTt2lL7oooukeTefqQ43wTA+WguMj1URvGPNiod27doFY2WL0/feey/yPUw5Ca2Lnj17Sl9++eXSbJnZoUMHaaborVq1kh4yZEgwVqbprFyh1USbhcdmusrKA7YI5oYL9nNhVRKre0KwEoD2S+/evaVZecEY2NuGVTu0d8iNN94ozXmRtA8GN/LkdMMKN1bRAgjFesMNN0izIotVLnHwumes7MnDY7O3C683XktsOfvZZ59Jc4Pbm2++KR2q8tgZboqipUjriFU8tIdoqXEOvPjii9K0HWnXjB8/XpprQBz+BW6MMSnFC7gxxqSUjFgovNPKPgVsY8lNHITpFlMsbgb44osvpGlLMPUKWQk7w1SW6T2f+LG3YE8EVgskTfVoESWtXPkLprQk9PSPF154QZobOZL2QjnzzDOlaXnR7tgXsP9Hkjv7r7zyivQTTzwhzSocbnbhHAv122FVDKsRmG6zdw5T6Th4HnIKbQZCO43pPTcKtW/fXpq9VuK49tprpfm0GV5XtMo4xhwnzjfOYT4smu2baTMltaZuvvlm6dtuu02a6wztOFoo3PzHa5Jr15NPPinNDVzDhg2Tfv/99xPF6l/gxhiTUryAG2NMSsmIhUJ7hJUKTJl4N5ubWpjqsWqFVRtvvPGG9F133SXNB7Gy0D8OVnZQ7y3uv/9+abZo5aaepLAHDDc1tGzZUnrQoEE5+kxaKLzj36JFC2lu8Eia7rNCY1888Pn000+X5kOun376aWlufAnRtWtXac5bprq0AVktwFSfm5JYtcHxGjp0qDSrpNiWNg5uOrryyiulaQMmgRvCeJ5pDQwfPlya1krS1res0Lr33nuluRmLNiftLq4H7H/zzDPPSLPKiRVTCxYskH733XcTxXrNNddI9+rVS5ob2DiXuEGKlhrj5uYdVlhxDnA9DD34eGf8C9wYY1KKF3BjjEkpGbFQmHIyjWGbTfY5YUrCO/vsoUH7gZs7mjVrJs0qj1B1RSbgd2CPhz2NiRuNmO6zQqdhw4bS7GfB/hLsHUF7g2NJW4J30bmRJY4kT6LZEz788MNInVNuueUWafaCefDBB6VpVxE+qYd2CtvGhjbKsIqCG4jiaNOmjTRbJzdt2lSaG0648YUtZGk10j4YMGCANJ+8c8EFF0jzKUpx8HhxD2rOCYybtgTt2Pnz50snte5o87I1MSviaJGFWtbScuGGJVaZ0Qrm+aR1zOtwZ/wL3BhjUooXcGOMSSkZsVCYorNihHdgWaVAmGJwE0SxYsWk+VQPVqHwySR8eG4c3PjB1q+8U8+Uid9t27Zt0tzgwKeLsAcFYRVKkp4dWVlZWf3795fm9+MdfMZHS4DpNNNBprescuHddY4FN2nFwbvqoTv13GhB24mx8nvyM1ltwD403EzBnjwhHnnkkV2+J7R5JfQ6N5YwvacVQ1uKm1tYBbEzbI/K64cVLRwjnn+OL/vFcAMJe9NMmDBBmvZQUm6//fYc/82uYLUOr6vOnTvv0efy+nvggQekQw/jZnUcryXaIFwb2GqYa0yon1Ec/gVujDEpxQu4McaklIw81NgYY8zex7/AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpXsCNMSaleAE3xpiU4gXcGGNSihdwY4xJKV7AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpuTNxkOzs7Bw9OTk7O1uaD10uVKiQ9MknnyxdoEAB6WnTpkmvWbNG+pdffuFn/n2AnShbtqwOyM+l3r59u/Svv/4aGWvu3H8PbZ48eaRXrlwpvXbtWukDDjhA+vrrr5fu1atXMNZcuXLpgAcffLBez5s3r/TWrVulf/vtt8jXDznkEH5m5PfZtGmT9J9//indoUMH6cceeywYa6VKlfRh+fPn1+sbNmyQ/v3336X32+/v3xb58uWL1EcccYR03bp1I1/neeOxzjvvvMhYczpXQxx00EHSNWvWlC5Tpoz0tm3bIt/zxx9/SD/66KPBMd1bsYaoUKGCdL169aQZ69SpU6VHjhwZjLV69eqKlfO+VKlS0ryueD3w2uV1xddXr14tvXnz5lAYIm4NyJ8/v2LduHGjXue1wTWK1xLj4xzYf//9pVetWiXN+XDggQdKz58/P1Gs/gVujDEpxQu4McaklGymyfvsIPs41SNMz5mKkriUpHTp0oq1cOHCep22xJYtW6SZSv3888/StBlCNkaIsmXLSi9ZsiQYa8WKFRUr00laBYTfhzHRHilRooQ0UzraQLSmaF0MGzYsGGu1atUUK60DxsEUmhYKrRXOV8bEz+FY1K9fPzLWZ599dp9aKHuLuLmayVjLlSsnfeihh0ofddRR0n379g3G2qRJE8X6/fff63XOdc5DWhGcb4cddpg0zzktxND1+eWXX0ovW7YsGGvu3LkVK20Tzkkeg1YJ7SFak8ccc4x06dKlpWn38Lr4/PPPpRcsWGALxRhj/ml4ATfGmJSSkSoUEqow2VuEbJOk8G770qVLpWlL1K5dW/qHH36QrlatmjTTu2XLlkUea/HixdKsZklis2Rl/WfauGjRosj30AbhMWg/MHXl3XxqHqtgwYLS77zzTqJYOR5MoZl+0qbi3X+eU84Z2mX8PoRVEj/99FOiWP8/wPGiHRBiyZIlkTo07jtDC4EVGTy3rNA6+uijpWktcL6wmoPzixUsPBZjiIPzMLRe8Xrg8Wi58DoeM2ZM5LFY6XPCCSdI0+6Mw7/AjTEmpXgBN8aYlJJxC6VKlSrSoUJ8bthhGsIqhZzCVCiOypUrSy9cuFC6atWq0kwhmfbREjn22GOlWdnBOJgmzZkzR5qpYRy0Mghtk+LFi0vTuihZsqR06O569erVIz+TFQJz585NFGuxYsWkOWa0QVjpsG7dOmlaU0xR33//fWmOK9Nm3uUP2Uz/H0limyRh8uTJid7H80PLjtc3q1s4x5YvXy5Ny4aWGG0MVoLwGqH9EgdtHc572qiMg2sXx7VGjRrSXEtCc5KaYxGHf4EbY0xK8QJujDEpJSMWCovv2aeCKTBhtQRhWlGnTh3pUaNG7TKGq666apfvycr6zzvQjJU2CPsX0AZi+sQ0jkX57du3ly5fvrw0raWPPvooUaxff/115Ou8I880kxZFaOPL+vXrpRs3bizNDRcLFixIFB+hXcR+JkwzGQcZOXKkNDfjcLNUqPdMkr4Y/zRoj61YsSJHf8tzw/HdU2hFcC7ROjz99NOlaVc0b95cmpYL5zOrPE477TRpWqK0ZuM466yzpGfNmiVNG5Dzip/L13md5NSyYqVbHP4FbowxKcULuDHGpJSMWCh333239PTp06VZDM90aObMmZGvs/qD1QjXXHONdL9+/SJjuOKKKxLFyk03LKyntULNu9y8e83KiTfeeEOa3//SSy+VpsWTdHNMaGNKKPXl5hjCShDaQ6+++qo0e4ok3WhEaJV06tQpMlZ+LtNP9phhys0089tvv5Vu0aKFNKskaA+FaNeunfQZZ5whzUoIVsh899130vwuEydOlM5pq1PGHwetNp7bL774Qpr9P2gBDBgwQJrzlt+Bth6vt5B1FwfnPauhaK8yjkmTJklffPHF0hxL9hThd/vxxx+l2a62SJEiiWLlNc1rlNcbN/nRHuF84/iRb775JjImnkNWrcThX+DGGJNSvIAbY0xKyYiFwrvODzzwgDR7C9AeYcE9X+fGEv4t07ALLrhAmtUpb775pvQpp5wSjHXgwIHSTJNYkUJYSXLiiSdGvofVMw0bNpTmUzeY9iYt4ieskuFGGcKeEoTtWqlpp/BuPDdUJd0cwTlw5JFHSjP9pDXFcWI7UY73V199Ffk5fP9NN90kPX78+F3GyaoFPvWJmyxo/XF+Mn2+7rrrpOfNmyfNucr4J0yYIH3cccftMs6srKysJk2aSNPKYRUKKypYncPXWSX14YcfSrPPT6gyLCmsMKKtQ0KvDxkyRPrwww+XZt8iPnmJ1xLHnv1VbrzxxmCsvP54vrgZiZUnvAbYXrdo0aLS3ORHi2bGjBnSPG+VKlUKxkf8C9wYY1KKF3BjjEkpGXkiz9y5c3WQ22+/Xa+HWiwS9ungZg3aASFrIMS+esoJ79TTcmnatKk0U25umrjkkkukaVd06tQpGGv9+vUVK3uScCMD02BW2LDy5NRTT5V+6qmnpNmzghun+H6m39OnTw/GWqxYMcXas2dPvc4qAVaVcCMH01iOMceSn8Pvz81In376qfSoUaMiY23VqpXipOXASgjON1YR0CagncZrjDF07txZmpbG8OHDpefPnx8c0zFjxkQ+1Jp9QfgdWM3DuUer8MILL5RmFRbPP6uFaDnGXVft27dXrDxe0oqrXdGyZUtpzpf+/ftLc0NQ3NOjpk2bplhpvXKMeW3QdqRVwqqaDz74QPqJJ56Qph1JS5UVKUOGDPETeYwx5p+GF3BjjEkpGalCee2116SZAieBKUZoEwQ36dCi4YYIpm1Joa3BO+EhmFrzjvqtt94qzbv5tDSYArZu3TpRfKw84caH7t27SzPtY4VFqCKBtgQ3LrAKg5spklZM8HjcCPPSSy9J884+KwH4HXjHf9q0adK04zp27CjNjSl33XXXLuNkNQdtk7PPPlua9gMrB2gB0QZj5RUre2h1cH7x8+OYMmWKNOc30/vQJi22GWb74tBDeUOb7pLCp+FwQ1Xbtm0jj811gpuA+N24yYab+XjtPffcc9K0OuLg2PAccZw4n6lZJcXrhzbanXfeGfk6N1e5F4oxxvzD8QJujDEpJSMWCvtU8G7snsBUt0ePHtJPP/20NC2GpBYK215Ssx0qK2NoJ4Rgfw1uUDnzzDOlaSskHSNuNKFVwFSZ4xSq4uEGl1AfDqZ648aNk+Z4x8G2phxX9gzJKUxFmTbTQgltumnUqFHkZ3Icucki9J7QE1VGjBgR+becO+z3kvSJUaRLly7SHNMkPV9C0A5gJVWSls1xDB48WJrnhxtfevXqJc3NLpzPrIChPURrhdYkK0+48ScOPmiY9uwrr7wizY02HHvavLz2zj33XGlWodx8882RMYQ2Du6Mf4EbY0xK8QJujDEpJSMWytChQ3P0fqaZrEJhylSxYkVpbqbo1q1b5Gc+9NBDiY7doUOHyGPwIcXsu0ErghUm3IjCKhxu5LjsssukmSYmTac5Ns2aNZNmO172iGCsrDAIPSy6VatW0ryDz4cGv/3224liJW3atMnx30TBtJ4W2dixYyPfP2jQIGm2yiXcEJX0gc27gueTNs6TTz65Vz4/K2vPbBNyzz33SLOiiz1FdgfOJVp5nFesPOE1xjnMqhBek++++6402wCzAizJxsGsrP9snUzbhNAeSUKoD09obUy6wdK/wI0xJqV4ATfGmJSSEQuF8A4v7xwzraKFwrSfGxxoE/Tp0yfyWGwby7vRcfAuN9M72jSMg5p3ztkalakeUzI+pYbVKe+9916iWFmFESL0dB5umgjBMWY1x+5w2223RX4uz3XIOuLcYGoZevgzW6LySUezZ8/OQcR7D7Yu7d27tzQtCtKgQYN9HlMSaJWxR8qwYcNy/FlscUzNDUzs1cKHbjMOVsmwRTEttFCVGKvh2M9nZ3L6IOgk0B565JFHpF9++WVpblJjJU0c/gVujDEpxQu4McaklIy0kzXGGLP38S9wY4xJKV7AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpXsCNMSaleAE3xpiU4gXcGGNSihdwY4xJKV7AjTEmpXgBN8aYlOIF3BhjUooXcGOMSSlewI0xJqV4ATfGmJTiBdwYY1KKF3BjjEkpXsCNMSal/C/RCGfj0dvyVgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 运行\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    W_val = sess.run(W)\n",
    "    print('weights:')\n",
    "    show_weights(W_val)\n",
    "\n",
    "    conv_val = sess.run(conv)\n",
    "    print('convolution results:')\n",
    "    print(np.shape(conv_val))\n",
    "    show_conv_results(conv_val)\n",
    "    \n",
    "\n",
    "    conv_out_val = sess.run(conv_out)\n",
    "    print('convolution with bias and relu:')\n",
    "    print(np.shape(conv_out_val))\n",
    "    show_conv_results(conv_out_val)\n",
    "\n",
    "\n",
    "    maxpool_val = sess.run(maxpool)\n",
    "    print('maxpool after all the convolutions:')\n",
    "    print(np.shape(maxpool_val))\n",
    "    show_conv_results(maxpool_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    完整网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 网络参数设置\n",
    "x = tf.placeholder(tf.float32, [None, 24 * 24])\n",
    "y = tf.placeholder(tf.float32, [None, len(names)])\n",
    "\n",
    "W1 = tf.Variable(tf.random_normal([5, 5, 1, 64]))\n",
    "b1 = tf.Variable(tf.random_normal([64]))\n",
    "\n",
    "W2 = tf.Variable(tf.random_normal([5, 5, 64, 64]))\n",
    "b2 = tf.Variable(tf.random_normal([64]))\n",
    "\n",
    "W3 = tf.Variable(tf.random_normal([6*6*64, 1024]))\n",
    "b3 = tf.Variable(tf.random_normal([1024]))\n",
    "\n",
    "W_out = tf.Variable(tf.random_normal([1024, len(names)]))\n",
    "b_out = tf.Variable(tf.random_normal([len(names)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 封装卷积和池化操作\n",
    "def conv_layer(x, W, b):\n",
    "    conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "    conv_with_b = tf.nn.bias_add(conv, b)\n",
    "    conv_out = tf.nn.relu(conv_with_b)\n",
    "    return conv_out\n",
    "\n",
    "def maxpool_layer(conv, k=2):\n",
    "    return tf.nn.max_pool(conv, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 模型\n",
    "def model():\n",
    "    x_reshaped = tf.reshape(x, shape=[-1, 24, 24, 1])\n",
    "\n",
    "    conv_out1 = conv_layer(x_reshaped, W1, b1)\n",
    "    maxpool_out1 = maxpool_layer(conv_out1)\n",
    "    # 提出了LRN层，对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，增强了模型的泛化能力。\n",
    "    # 推荐阅读http://blog.csdn.net/banana1006034246/article/details/75204013\n",
    "    norm1 = tf.nn.lrn(maxpool_out1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "    conv_out2 = conv_layer(norm1, W2, b2)\n",
    "    norm2 = tf.nn.lrn(conv_out2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "    maxpool_out2 = maxpool_layer(norm2)\n",
    "\n",
    "    maxpool_reshaped = tf.reshape(maxpool_out2, [-1, W3.get_shape().as_list()[0]])\n",
    "    local = tf.add(tf.matmul(maxpool_reshaped, W3), b3)\n",
    "    local_out = tf.nn.relu(local)\n",
    "\n",
    "    out = tf.add(tf.matmul(local_out, W_out), b_out)\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 损失与学习率\n",
    "learning_rate = 0.003\n",
    "model_op = model()\n",
    "\n",
    "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=model_op, labels=y))\n",
    "train_op = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "\n",
    "correct_pred = tf.equal(tf.argmax(model_op, 1), tf.argmax(y, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch size 64\n",
      "Epoch 0. Avg accuracy 0.2375119884910486\n",
      "Epoch 1. Avg accuracy 0.28156969309462915\n",
      "Epoch 2. Avg accuracy 0.31038203324808183\n",
      "Epoch 3. Avg accuracy 0.32376918158567775\n",
      "Epoch 4. Avg accuracy 0.34029331841432225\n",
      "Epoch 5. Avg accuracy 0.3500039961636829\n",
      "Epoch 6. Avg accuracy 0.3575967071611253\n",
      "Epoch 7. Avg accuracy 0.3616727941176471\n",
      "Epoch 8. Avg accuracy 0.3797953964194373\n",
      "Epoch 9. Avg accuracy 0.3855099104859335\n"
     ]
    }
   ],
   "source": [
    "# 运行\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    onehot_labels = tf.one_hot(labels, len(names), axis=-1)\n",
    "    onehot_vals = sess.run(onehot_labels)\n",
    "    \n",
    "    batch_size = 64\n",
    "    print('batch size', batch_size)\n",
    "    \n",
    "    for j in range(0, 10):\n",
    "        avg_accuracy_val = 0.\n",
    "        batch_count = 0.\n",
    "        \n",
    "        for i in range(0, len(data), batch_size):\n",
    "            batch_data = data[i:i+batch_size, :]\n",
    "            batch_onehot_vals = onehot_vals[i:i+batch_size, :]\n",
    "            _, accuracy_val = sess.run([train_op, accuracy], feed_dict={x: batch_data, y: batch_onehot_vals})\n",
    "            avg_accuracy_val += accuracy_val\n",
    "            batch_count += 1.\n",
    "        avg_accuracy_val /= batch_count\n",
    "        print('Epoch {}. Avg accuracy {}'.format(j, avg_accuracy_val))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
